package PenTest.Solution5;
import java.io.*;
import java.util.*;

public class Solution {
    public static int row ;
    public static  int col ;

    public static int ret ;


    public static void main(String[] args) {
       List<ArrayList<Integer>> grid = new  ArrayList<ArrayList<Integer>>();


    }
    public static int rotApple (ArrayList<ArrayList<Integer>> grid) {
        row = grid.size();
        col = grid.get(0).size();

        ret =  Integer.MIN_VALUE;
        int[][] nums = new int[row][col];
        int  starti = 0, startj = 0;

        // 拷贝一份
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                nums[i][j] = grid.get(i).get(j);
                if (nums[i][j] == 2) {
                    starti = i;
                    startj = j;
                }
            }
        }



       int count = dfs(nums, starti, startj, 0);


        return ret ;

    }


    public static int dfs(int[][] nums, int i, int j,  int minute) {



        // 上
        if (checkIndex(i - 1, j) || nums[i - 1][j]  == 1 ) {
            int up = dfs(nums, i - 1, j, minute + 1);
            ret = Math.max(ret, up);

        }

        // 下
        if (checkIndex(i + 1, j) || nums[i + 1][j]  == 1 ) {
            int down = dfs(nums, i + 1, j, minute + 1);
            ret = Math.max(ret, down);
        }

        // 左
        if (checkIndex(i , j - 1) || nums[i][j - 1]  == 1 ) {
            int left = dfs(nums, i, j - 1, minute + 1);
            ret = Math.max(ret, left);
        }

        // 右
        if (checkIndex(i , j + 1) || nums[i][j + 1]  == 1 ) {
            int right = dfs(nums, i, j + 1, minute + 1);
            ret = Math.max(ret, right);
        }


        return minute;
    }

    public static boolean checkIndex(int x, int y) {
        return (x >= 0 && x < row &&  y >= 0 && y < col);
    }

}



// 注意类名必须为 Main, 不要有任何 package xxx 信息

/**
 * 题目： 游游的you
 *
 *
 */
 class Main1 {
    public static PrintWriter out = new PrintWriter(new BufferedWriter(
            new OutputStreamWriter(System.out)));
    public static Read in = new Read();

    public static void main(String[] args) throws IOException {


        int q = in.nextInt();

        for (int i = 0; i < q; i++) {
            int a = in.nextInt();
            int b = in.nextInt();
            int c = in.nextInt();

            int socre  = 0;


            while (a > 0 && c > 0 && b > 0) {
                socre += 2;
                a--;
                b--;
                c--;
            }

            if (b > 0)
                socre += (b - 1);

            System.out.println(socre);
        }
    }
}

class Read { // 自定义快速读入
    StringTokenizer st = new StringTokenizer("");
    BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
    String next() throws IOException, IOException {
        while (!st.hasMoreTokens()) {
            st = new StringTokenizer(bf.readLine());
        }
        return st.nextToken();
    }

    String nextLine() throws IOException {
        return bf.readLine();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }
}


/**
 * 题目： 腐烂的苹果
 *
 */


class Solution1 {
    public static int row ;
    public static  int col ;

    public static int ret ;
    public int rotApple (ArrayList<ArrayList<Integer>> grid) {
        row = grid.size();
        col = grid.get(0).size();

        ret =  Integer.MIN_VALUE;
        int[][] nums = new int[row][col];
        int  starti = 0, startj = 0;

        // 拷贝一份
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                nums[i][j] = grid.get(i).get(j);
                if (nums[i][j] == 2) {
                    starti = i;
                    startj = j;
                }
            }
        }


        dfs(nums, starti, startj, 0);

        for(int i=0; i < row ; i++) {
            for(int j=0; j < row ; j++) {
                if(nums[i][j]==1) {
                    return -1;
                }
            }
        }

        return ret ;

    }


    public  void dfs(int[][] nums, int i, int j,  int minute) {
        if (i == row-1 && j == col -1)    {
            ret = Math.max(ret, minute);
            return;
        }




        // 上
        if (checkIndex(i - 1, j) && nums[i - 1][j]  == 1 ) {
            nums[i - 1][j] =  2;

            dfs(nums, i - 1, j, minute + 1);

            //  ret = Math.max(ret, minute);

        }

        // 下
        if (checkIndex(i + 1, j) && nums[i + 1][j]  == 1 ) {
            nums[i + 1][j] =  2;
            dfs(nums, i + 1, j, minute + 1);
            // ret = Math.max(ret, minute);
        }

        // 左
        if (checkIndex(i, j - 1) && nums[i][j - 1]  == 1 ) {
            nums[i][j - 1] =  2;
            dfs(nums, i, j - 1, minute + 1);
            // ret = Math.max(ret, minute);
        }

        // 右
        if (checkIndex(i, j + 1) && nums[i][j + 1]  == 1 ) {
            nums[i][j + 1] =  2;
            dfs(nums, i, j + 1, minute + 1);
            // ret = Math.max(ret, minute);
        }



    }

    public static boolean checkIndex(int x, int y) {
        return (x >= 0 && x < row &&  y >= 0 && y < col);
    }

}


/**
 * 题目： 孩子们的游戏
 *
 *
 */




 class Solution2 {

    ListNode root;

    public int LastRemaining_Solution (int n, int m) {

        root = new ListNode(0);
        ListNode cur = root;
        for (int i = 1; i < n; i++) {
            cur.next = new ListNode(i);
            cur = cur.next;
        }

        // 实现收尾相连
        cur.next = root;


        return findLast(root , m);

    }


    public static int findLast(ListNode root , int m) {
        ListNode prev = null;
        while(root.next != root) {
            for(int i=1; i < m; i++) {
                prev = root;
                root = root.next;
            }

            prev.next = root.next;
            root = prev.next;

        }


        return root.val;
    }
}




class ListNode {
    int val ;
    ListNode next;

    public ListNode(int val) {
        this.val = val;
    }
}


/**
 * 题目：单词搜索
 * 1. 定义一个同规模的布尔的二维数组
 * 2、 进行判断
 */




 class Solution3 {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param board string字符串一维数组
     * @param word string字符串
     * @return bool布尔型
     */
    int row ;
    int col ;
    int index ;

    // boolean[][] check;
    public boolean exist (String[] board, String word) {
        // write code here
        index = 1;
        row = board.length;
        col = board[0].length();
        int wlen = word.length();


        char[][] strs = new char[row][col];
        // check = new boolean[row][col];

        for (int i = 0; i < row; i++) {
            strs[i] = board[i].toCharArray();
        }

        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col ; j++) {
                if (board[i].charAt(j) == word.charAt(0)  &&
                        dfs(  strs ,word.toCharArray(), i, j))   return true;
            }
        }


        return false;
    }

    public boolean dfs(char[][] strs, char[] word, int i, int j) {
        // 递归出口
        if (index == word.length) {
            return true;
        }



        // 开始深搜
        // 上
        if (checkIndex(i - 1, j) && strs[i - 1][j] == word[index]) {
            strs[i][j] = '#';
            index++;
            if ( dfs(strs, word, i - 1, j))  return true;

            index--;
        }
        // 下
        if (checkIndex(i + 1, j) && strs[i + 1][j] == word[index]) {
            strs[i][j] = '#';
            index++;
            if ( dfs(strs, word, i + 1, j))  return true;

            index--;
        }

        // 左
        if (checkIndex(i, j - 1) && strs[i ][j - 1 ] == word[index]) {
            strs[i][j] = '#';
            index++;
            if ( dfs(strs, word, i, j - 1))  return true;

            index--;
        }

        // 右
        if (checkIndex(i, j + 1) && strs[i ][j + 1] == word[index]) {
            strs[i][j] = '#';
            index++;
            if ( dfs(strs, word, i, j + 1))  return true;

            index--;
        }



        return false;
    }


    public boolean checkIndex(int x, int y) {
        return  (x >= 0 && x < row && y >= 0 && y <  col) ;
    }



}


/**
 * 题目： 单词搜索
 *
 * 1. 先定义全局变量
 * 二维数组的长度，宽度 以及 上下左右移动的两个数组 和 以及每次出现布尔 判断是否走过
 * 2. 遍历二维数组先找到第一个字母出现的位置
 *
 * 3. 找到之后进行深搜， 走过的路check 置为 true
 *
 * 4. 进行坐标的有界性 和 是否走过 和是否走过 的上下左右移动
 *
 * 5. 一但有就两个下标相等 返回并且中途一直  true
 *
 * 6. 最后回溯时 当前位置还原为 false 并且 返回 false
 */



 class Solution4 {

    // 二维数组的长度和宽度
    int row ;
    int col;

    // 单词的长度
    int len;

    // 判断路径是否走过
    boolean [][] check;

    // 用来确定上下左右的方位数组
    int[] m = {0, 0, -1, 1};
    int[] n = {-1, 1, 0, 0};
    public boolean exist (String[] board, String word) {
        // 得到宽度和长度
        row = board.length;
        col = board[0].length();

        len = word.length();

        check = new boolean[row][col];
// 先找到word 的起始位置
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col ; j++) {
                // 开始判断是否是第一个位置
                if (board[i].charAt(j) == word.charAt(0)) {
                    // 开始搜索二维数组中存在的单词
                    // 如果为 true就说明存在
                    if (dfs(board, word, i, j, 0) == true) {
                        return true;

                    }

                }

            }

        }
        // 否则出了循环就证明没有找到该单词就返回false
        return false;

    }

    public boolean dfs(String[] board, String word, int i, int j, int pos) {
        // 一旦找寻的长度等于单词的长度说明已经找到就返回true
        if (pos == len - 1) {

            return true;

        }

        // 到达这个位置就把这个位置置为true
        check[i][j] = true;

        // 开始遍历
        // 4个方位
        for (int k = 0; k < 4; k++) {


            // // 用来确定上下左右的方位数组
            // int[] m ={0,0,-1,1};
            // int[] n = {-1,1,0,0};

            int x = i + m[k];
            int y = j + n[k];

            // 意思就是说通过坐标的+1 和 -1 实现上下左右

            if (x >= 0 && x < row && y >= 0 && y < col &&
                    !check[x][y]  &&
                    board[x].charAt(y) == word.charAt(pos + 1) ) {
                if (dfs(board, word, x, y, pos + 1) == true) {
                    return true;

                };

            }


        }

        check[i][j] = false;


        return false ;

    }
}



class Test {
    public static void main(String[] args) {
        String s = "10000000000";
        String t=  "10000000000";
       long a= Long.valueOf(s);
      Long b =  Long.valueOf(t);
      Long c = (Long) (a*b);
        System.out.println(String.valueOf(c));
    }
}


/**
 * 题目： 两个数组的交集
 * 算法思路 1：
 * 遍历数组一利用哈希表来记录数组一是否出现过 就置为 true
 * 再遍历数组二 需要哈希表中出现的数字，然后利用把该数组置为 false
 */


class Solution5 {



    public ArrayList<Integer> intersection (ArrayList<Integer> nums1, ArrayList<Integer> nums2) {
        // 创建 一个 Hash数组
        boolean[] hash = new boolean[1010];

        // 存储返回值
        ArrayList<Integer> ret = new ArrayList<>();

        for(int i=0; i < nums1.size(); i++) {
            int num = nums1.get(i);
            if(!hash[num]) hash[num]=true;
        }

        for(int i=0; i < nums2.size(); i++) {
            int num = nums2.get(i);
            if(hash[num]) {
                ret.add(num);
                hash[num] = false;
            }
        }

        return ret;

    }
}

// 题目： 两数组的交集
//思路二： 排序 + 双指针

 class Solution6 {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param nums1 int整型ArrayList
     * @param nums2 int整型ArrayList
     * @return int整型ArrayList
     */
    public ArrayList<Integer> intersection (ArrayList<Integer> nums1, ArrayList<Integer> nums2) {
// write code here
        ArrayList<Integer> ret = new ArrayList<>();
// 先排序
        Collections.sort(nums1);
        Collections.sort(nums2);
        int cur1 =0, cur2 =0;
// 临时变量去重
        int flg =0;
        while(cur1 < nums1.size() && cur2 < nums2.size()) {
            int n1= nums1.get(cur1);
            int n2= nums2.get(cur2);
            if(n1 < n2) {
                cur1++;
            } else if (n1 > n2){
                cur2++;
            } else {
// 进行去重操作
                if(n1 != flg) {
                    ret.add(n1);
                    flg = n1;
                }
                cur1++;
                cur2++;
            }
        }
        return ret;
    }
}



// 注意类名必须为 Main, 不要有任何 package xxx 信息


/**
 * 题目: 点击清除
 *  思路一: 栈
 *
 *
 *  下面的是思路二:
 *  利用StringBuilder 对字符串进行 增加和删除
 *  有就尾删, 没有就尾插
 *
 */
 class Main2 {

    public static void main(String[] args) {

        // 输入
        Scanner in = new Scanner(System.in);
        String str = in.next();

        // 创建一个字符串来加入和清除
        StringBuilder ret = new StringBuilder();

//        开始遍历
        for(int i=0; i < str.length(); i++) {

            char ch = str.charAt(i);

//            如果字符串为 空 或 最后一个字符 不等于该字符 就加入
            if(ret.isEmpty() || ret.charAt(ret.length()-1) != ch) {
                ret.append(ch);
            } else {
//                一旦相同就删除最后一个字符
                ret.deleteCharAt(ret.length()-1);
            }
        }

//        如果为 空 就打印 0
        if(ret.isEmpty()) System.out.println(0);

        System.out.println(ret.toString());
    }
}


/**
 * 题目: 牛牛的快递
 *
 * 学会使用 Math 中的 ceil 进行向上取整
 *
 */


// 注意类名必须为 Main, 不要有任何 package xxx 信息
 class Main3 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        double a = in.nextDouble();
        String b = in.next();

        int sum = 20;

        if(a > 1) {
            sum += Math.ceil(a) -1;
        }

        if(b.equals("y")) {
            sum += 5;
        }

        System.out.print(sum);
    }
}


/**
 * dd 爱框框
 * 1. 利用滑动窗口
 * 2. 入窗口：right 向右走 sum一直加
 * 3。更新结果: 达到要求就更新结果 和 长度，
 * 4. 出窗口：  并且 减去 left 位置的数据
 *
 * 此题数据量比较大，要自己写一个输入的方法
 */
 class Main {

    public static void main(String[] args) throws IOException {
        Read in = new Read();
        // 输入
        int len = in.nextInt();

        // 目标值
        int target = in.nextInt();

        int[] nums = new int[len+1];

        for(int i=1; i<= len; i++) {
            nums[i] = in.nextInt();
        }

//         进行算法
        int left =1, right =1;
        int leftret = -1, rightret = -1;
        int ret = len,sum =0;;
//         进行滑动窗口算法
        while(right <= len ) {
//             入窗口
            sum += nums[right];

            while(sum >= target) {
//                  更新结果
                if(right-left + 1 < ret) {
                    leftret = left;
                    rightret = right;
                    ret = right - left + 1;
                }

                // 出窗口
                sum -= nums[left];
                left++;
            }

            right ++;
        }

        System.out.println(leftret + " " + rightret);
    }
}

class Read1 // 自定义快速读入
{
    StringTokenizer st = new StringTokenizer("");
    BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
    String next() throws IOException
    {
        while(!st.hasMoreTokens())
        {
            st = new StringTokenizer(bf.readLine());
        }
        return st.nextToken();
    }

    String nextLine() throws IOException
    {
        return bf.readLine();
    }

    int nextInt() throws IOException
    {
        return Integer.parseInt(next());
    }

    long nextLong() throws IOException
    {
        return Long.parseLong(next());
    }

    double nextDouble() throws IOException
    {
        return Double.parseDouble(next());
    }
}



